﻿// Decompiled with JetBrains decompiler
// Type: UnityEngine.SystemInfo
// Assembly: UnityEngine.CoreModule, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: E6AE6B5A-2752-4B07-9528-C8B77C62CE79
// Assembly location: C:\Users\windys\Unity\2021.3.39f1c1\Editor\Data\Managed\UnityEngine\UnityEngine.CoreModule.dll
// XML documentation location: C:\Users\windys\Unity\2021.3.39f1c1\Editor\Data\Managed\UnityEngine\UnityEngine.CoreModule.xml

using System;
using System.Reflection;
using System.Runtime.CompilerServices;
using UnityEngine.Bindings;
using UnityEngine.Experimental.Rendering;
using UnityEngine.Rendering;

#nullable disable
namespace UnityEngine
{
  /// <summary>
  ///   <para>Access system and hardware information.</para>
  /// </summary>
  [NativeHeader("Runtime/Misc/SystemInfo.h")]
  [NativeHeader("Runtime/Input/GetInput.h")]
  [NativeHeader("Runtime/Shaders/GraphicsCapsScriptBindings.h")]
  [NativeHeader("Runtime/Graphics/GraphicsFormatUtility.bindings.h")]
  [NativeHeader("Runtime/Camera/RenderLoops/MotionVectorRenderLoop.h")]
  [NativeHeader("Runtime/Graphics/Mesh/MeshScriptBindings.h")]
  public sealed class SystemInfo
  {
    /// <summary>
    ///   <para>Value returned by SystemInfo string properties which are not supported on the current platform.</para>
    /// </summary>
    public const string unsupportedIdentifier = "n/a";

    /// <summary>
    ///   <para>The current battery level (Read Only).</para>
    /// </summary>
    [NativeProperty]
    public static float batteryLevel => SystemInfo.GetBatteryLevel();

    /// <summary>
    ///   <para>Returns the current status of the device's battery (Read Only).</para>
    /// </summary>
    public static BatteryStatus batteryStatus => SystemInfo.GetBatteryStatus();

    /// <summary>
    ///   <para>Operating system name with version (Read Only).</para>
    /// </summary>
    public static string operatingSystem => SystemInfo.GetOperatingSystem();

    /// <summary>
    ///   <para>Returns the operating system family the game is running on (Read Only).</para>
    /// </summary>
    public static OperatingSystemFamily operatingSystemFamily
    {
      get => SystemInfo.GetOperatingSystemFamily();
    }

    /// <summary>
    ///   <para>Processor name (Read Only).</para>
    /// </summary>
    public static string processorType => SystemInfo.GetProcessorType();

    /// <summary>
    ///   <para>Processor frequency in MHz (Read Only).</para>
    /// </summary>
    public static int processorFrequency => SystemInfo.GetProcessorFrequencyMHz();

    /// <summary>
    ///   <para>Number of processors present (Read Only).</para>
    /// </summary>
    public static int processorCount => SystemInfo.GetProcessorCount();

    /// <summary>
    ///   <para>Amount of system memory present (Read Only).</para>
    /// </summary>
    public static int systemMemorySize => SystemInfo.GetPhysicalMemoryMB();

    /// <summary>
    ///   <para>A unique device identifier. It's guaranteed to be unique for every device (Read Only).</para>
    /// </summary>
    public static string deviceUniqueIdentifier => SystemInfo.GetDeviceUniqueIdentifier();

    /// <summary>
    ///   <para>The user defined name of the device (Read Only).</para>
    /// </summary>
    public static string deviceName => SystemInfo.GetDeviceName();

    /// <summary>
    ///   <para>The model of the device (Read Only).</para>
    /// </summary>
    public static string deviceModel => SystemInfo.GetDeviceModel();

    /// <summary>
    ///   <para>Is an accelerometer available on the device?</para>
    /// </summary>
    public static bool supportsAccelerometer => SystemInfo.SupportsAccelerometer();

    /// <summary>
    ///   <para>Is a gyroscope available on the device?</para>
    /// </summary>
    public static bool supportsGyroscope => SystemInfo.IsGyroAvailable();

    /// <summary>
    ///   <para>Is the device capable of reporting its location?</para>
    /// </summary>
    public static bool supportsLocationService => SystemInfo.SupportsLocationService();

    /// <summary>
    ///   <para>Is the device capable of providing the user haptic feedback by vibration?</para>
    /// </summary>
    public static bool supportsVibration => SystemInfo.SupportsVibration();

    /// <summary>
    ///   <para>Is there an Audio device available for playback? (Read Only)</para>
    /// </summary>
    public static bool supportsAudio => SystemInfo.SupportsAudio();

    /// <summary>
    ///   <para>Returns the kind of device the application is running on (Read Only).</para>
    /// </summary>
    public static DeviceType deviceType => SystemInfo.GetDeviceType();

    /// <summary>
    ///   <para>Amount of video memory present (Read Only).</para>
    /// </summary>
    public static int graphicsMemorySize => SystemInfo.GetGraphicsMemorySize();

    /// <summary>
    ///   <para>The name of the graphics device (Read Only).</para>
    /// </summary>
    public static string graphicsDeviceName => SystemInfo.GetGraphicsDeviceName();

    /// <summary>
    ///   <para>The vendor of the graphics device (Read Only).</para>
    /// </summary>
    public static string graphicsDeviceVendor => SystemInfo.GetGraphicsDeviceVendor();

    /// <summary>
    ///   <para>The identifier code of the graphics device (Read Only).</para>
    /// </summary>
    public static int graphicsDeviceID => SystemInfo.GetGraphicsDeviceID();

    /// <summary>
    ///   <para>The identifier code of the graphics device vendor (Read Only).</para>
    /// </summary>
    public static int graphicsDeviceVendorID => SystemInfo.GetGraphicsDeviceVendorID();

    /// <summary>
    ///   <para>The graphics API type used by the graphics device (Read Only).</para>
    /// </summary>
    public static GraphicsDeviceType graphicsDeviceType => SystemInfo.GetGraphicsDeviceType();

    /// <summary>
    ///   <para>Returns true if the texture UV coordinate convention for this platform has Y starting at the top of the image.</para>
    /// </summary>
    public static bool graphicsUVStartsAtTop => SystemInfo.GetGraphicsUVStartsAtTop();

    /// <summary>
    ///   <para>The graphics API type and driver version used by the graphics device (Read Only).</para>
    /// </summary>
    public static string graphicsDeviceVersion => SystemInfo.GetGraphicsDeviceVersion();

    /// <summary>
    ///   <para>Graphics device shader capability level (Read Only).</para>
    /// </summary>
    public static int graphicsShaderLevel => SystemInfo.GetGraphicsShaderLevel();

    /// <summary>
    ///   <para>Is graphics device using multi-threaded rendering (Read Only)?</para>
    /// </summary>
    public static bool graphicsMultiThreaded => SystemInfo.GetGraphicsMultiThreaded();

    /// <summary>
    ///   <para>Application's actual rendering threading mode (Read Only).</para>
    /// </summary>
    public static RenderingThreadingMode renderingThreadingMode
    {
      get => SystemInfo.GetRenderingThreadingMode();
    }

    /// <summary>
    ///   <para>True if the GPU supports hidden surface removal.</para>
    /// </summary>
    public static bool hasHiddenSurfaceRemovalOnGPU => SystemInfo.HasHiddenSurfaceRemovalOnGPU();

    /// <summary>
    ///   <para>Returns true when the GPU has native support for indexing uniform arrays in fragment shaders without restrictions.</para>
    /// </summary>
    public static bool hasDynamicUniformArrayIndexingInFragmentShaders
    {
      get => SystemInfo.HasDynamicUniformArrayIndexingInFragmentShaders();
    }

    /// <summary>
    ///   <para>Are built-in shadows supported? (Read Only)</para>
    /// </summary>
    public static bool supportsShadows => SystemInfo.SupportsShadows();

    /// <summary>
    ///   <para>Is sampling raw depth from shadowmaps supported? (Read Only)</para>
    /// </summary>
    public static bool supportsRawShadowDepthSampling
    {
      get => SystemInfo.SupportsRawShadowDepthSampling();
    }

    /// <summary>
    ///   <para>Are render textures supported? (Read Only)</para>
    /// </summary>
    [Obsolete("supportsRenderTextures always returns true, no need to call it")]
    public static bool supportsRenderTextures => true;

    /// <summary>
    ///   <para>Whether motion vectors are supported on this platform.</para>
    /// </summary>
    public static bool supportsMotionVectors => SystemInfo.SupportsMotionVectors();

    /// <summary>
    ///   <para>Are cubemap render textures supported? (Read Only)</para>
    /// </summary>
    [Obsolete("supportsRenderToCubemap always returns true, no need to call it")]
    public static bool supportsRenderToCubemap => true;

    /// <summary>
    ///   <para>Are image effects supported? (Read Only)</para>
    /// </summary>
    [Obsolete("supportsImageEffects always returns true, no need to call it")]
    public static bool supportsImageEffects => true;

    /// <summary>
    ///   <para>Are 3D (volume) textures supported? (Read Only)</para>
    /// </summary>
    public static bool supports3DTextures => SystemInfo.Supports3DTextures();

    /// <summary>
    ///   <para>Are compressed formats for 3D (volume) textures supported? (Read Only).</para>
    /// </summary>
    public static bool supportsCompressed3DTextures => SystemInfo.SupportsCompressed3DTextures();

    /// <summary>
    ///   <para>Are 2D Array textures supported? (Read Only)</para>
    /// </summary>
    public static bool supports2DArrayTextures => SystemInfo.Supports2DArrayTextures();

    /// <summary>
    ///   <para>Are 3D (volume) RenderTextures supported? (Read Only)</para>
    /// </summary>
    public static bool supports3DRenderTextures => SystemInfo.Supports3DRenderTextures();

    /// <summary>
    ///   <para>Are Cubemap Array textures supported? (Read Only)</para>
    /// </summary>
    public static bool supportsCubemapArrayTextures => SystemInfo.SupportsCubemapArrayTextures();

    /// <summary>
    ///   <para>Returns true when anisotropic filtering is supported on the device.</para>
    /// </summary>
    public static bool supportsAnisotropicFilter => SystemInfo.SupportsAnisotropicFilter();

    /// <summary>
    ///   <para>Support for various Graphics.CopyTexture cases (Read Only).</para>
    /// </summary>
    public static CopyTextureSupport copyTextureSupport => SystemInfo.GetCopyTextureSupport();

    /// <summary>
    ///   <para>Are compute shaders supported? (Read Only)</para>
    /// </summary>
    public static bool supportsComputeShaders => SystemInfo.SupportsComputeShaders();

    /// <summary>
    ///   <para>Are geometry shaders supported? (Read Only)</para>
    /// </summary>
    public static bool supportsGeometryShaders => SystemInfo.SupportsGeometryShaders();

    /// <summary>
    ///   <para>Are tessellation shaders supported? (Read Only)</para>
    /// </summary>
    public static bool supportsTessellationShaders => SystemInfo.SupportsTessellationShaders();

    /// <summary>
    ///   <para>Boolean that indicates if SV_RenderTargetArrayIndex can be used in a vertex shader (true if it can be used, false if not).</para>
    /// </summary>
    public static bool supportsRenderTargetArrayIndexFromVertexShader
    {
      get => SystemInfo.SupportsRenderTargetArrayIndexFromVertexShader();
    }

    /// <summary>
    ///   <para>Is GPU draw call instancing supported? (Read Only)</para>
    /// </summary>
    public static bool supportsInstancing => SystemInfo.SupportsInstancing();

    /// <summary>
    ///   <para>Does the hardware support quad topology? (Read Only)</para>
    /// </summary>
    public static bool supportsHardwareQuadTopology => SystemInfo.SupportsHardwareQuadTopology();

    /// <summary>
    ///   <para>Are 32-bit index buffers supported? (Read Only)</para>
    /// </summary>
    public static bool supports32bitsIndexBuffer => SystemInfo.Supports32bitsIndexBuffer();

    /// <summary>
    ///   <para>Are sparse textures supported? (Read Only)</para>
    /// </summary>
    public static bool supportsSparseTextures => SystemInfo.SupportsSparseTextures();

    /// <summary>
    ///   <para>How many simultaneous render targets (MRTs) are supported? (Read Only)</para>
    /// </summary>
    public static int supportedRenderTargetCount => SystemInfo.SupportedRenderTargetCount();

    /// <summary>
    ///   <para>Returns true when the platform supports different blend modes when rendering to multiple render targets, or false otherwise.</para>
    /// </summary>
    public static bool supportsSeparatedRenderTargetsBlend
    {
      get => SystemInfo.SupportsSeparatedRenderTargetsBlend();
    }

    /// <summary>
    ///   <para>The maximum number of random write targets (UAV) that Unity supports simultaneously. (Read Only)</para>
    /// </summary>
    public static int supportedRandomWriteTargetCount
    {
      get => SystemInfo.SupportedRandomWriteTargetCount();
    }

    /// <summary>
    ///   <para>Are multisampled textures supported? (Read Only)</para>
    /// </summary>
    public static int supportsMultisampledTextures => SystemInfo.SupportsMultisampledTextures();

    /// <summary>
    ///   <para>Boolean that indicates whether multisampled texture arrays are supported (true if supported, false if not supported).</para>
    /// </summary>
    public static bool supportsMultisampled2DArrayTextures
    {
      get => SystemInfo.SupportsMultisampled2DArrayTextures();
    }

    /// <summary>
    ///   <para>Returns true if multisampled textures are resolved automatically</para>
    /// </summary>
    public static bool supportsMultisampleAutoResolve
    {
      get => SystemInfo.SupportsMultisampleAutoResolve();
    }

    /// <summary>
    ///   <para>Returns true if the 'Mirror Once' texture wrap mode is supported. (Read Only)</para>
    /// </summary>
    public static int supportsTextureWrapMirrorOnce => SystemInfo.SupportsTextureWrapMirrorOnce();

    /// <summary>
    ///   <para>This property is true if the current platform uses a reversed depth buffer (where values range from 1 at the near plane and 0 at far plane), and false if the depth buffer is normal (0 is near, 1 is far). (Read Only)</para>
    /// </summary>
    public static bool usesReversedZBuffer => SystemInfo.UsesReversedZBuffer();

    /// <summary>
    ///   <para>Is the stencil buffer supported? (Read Only)</para>
    /// </summary>
    [Obsolete("supportsStencil always returns true, no need to call it")]
    public static int supportsStencil => 1;

    internal static bool IsEnumValueObsolete(Enum value)
    {
      foreach (FieldInfo field in value.GetType().GetFields(BindingFlags.Static | BindingFlags.Public))
      {
        if (object.Equals(field.GetValue((object) null), (object) value) && field.GetCustomAttributes(typeof (ObsoleteAttribute), false).Length == 0)
          return false;
      }
      return true;
    }

    private static bool IsValidEnumValue(Enum value)
    {
      return Enum.IsDefined(value.GetType(), (object) value) && !SystemInfo.IsEnumValueObsolete(value);
    }

    /// <summary>
    ///   <para>Is render texture format supported?</para>
    /// </summary>
    /// <param name="format">The format to look up.</param>
    /// <returns>
    ///   <para>True if the format is supported.</para>
    /// </returns>
    public static bool SupportsRenderTextureFormat(RenderTextureFormat format)
    {
      return SystemInfo.IsValidEnumValue((Enum) format) ? SystemInfo.HasRenderTextureNative(format) : throw new ArgumentException("Failed SupportsRenderTextureFormat; format is not a valid RenderTextureFormat");
    }

    /// <summary>
    ///   <para>Is blending supported on render texture format?</para>
    /// </summary>
    /// <param name="format">The format to look up.</param>
    /// <returns>
    ///   <para>True if blending is supported on the given format.</para>
    /// </returns>
    public static bool SupportsBlendingOnRenderTextureFormat(RenderTextureFormat format)
    {
      return SystemInfo.IsValidEnumValue((Enum) format) ? SystemInfo.SupportsBlendingOnRenderTextureFormatNative(format) : throw new ArgumentException("Failed SupportsBlendingOnRenderTextureFormat; format is not a valid RenderTextureFormat");
    }

    /// <summary>
    ///   <para>Tests if a RenderTextureFormat can be used with RenderTexture.enableRandomWrite.</para>
    /// </summary>
    /// <param name="format">The format to look up.</param>
    /// <returns>
    ///   <para>True if the format can be used for random access writes.</para>
    /// </returns>
    public static bool SupportsRandomWriteOnRenderTextureFormat(RenderTextureFormat format)
    {
      return SystemInfo.IsValidEnumValue((Enum) format) ? SystemInfo.SupportsRandomWriteOnRenderTextureFormatNative(format) : throw new ArgumentException("Failed SupportsRandomWriteOnRenderTextureFormat; format is not a valid RenderTextureFormat");
    }

    /// <summary>
    ///   <para>Is texture format supported on this device?</para>
    /// </summary>
    /// <param name="format">The TextureFormat format to look up.</param>
    /// <returns>
    ///   <para>True if the format is supported.</para>
    /// </returns>
    public static bool SupportsTextureFormat(TextureFormat format)
    {
      return SystemInfo.IsValidEnumValue((Enum) format) ? SystemInfo.SupportsTextureFormatNative(format) : throw new ArgumentException("Failed SupportsTextureFormat; format is not a valid TextureFormat");
    }

    /// <summary>
    ///   <para>Indicates whether the given combination of a vertex attribute format and dimension is supported on this device.</para>
    /// </summary>
    /// <param name="format">The VertexAttributeFormat format to look up.</param>
    /// <param name="dimension">The dimension of vertex data to check for.</param>
    /// <returns>
    ///   <para>True if the format with the given dimension is supported.</para>
    /// </returns>
    public static bool SupportsVertexAttributeFormat(VertexAttributeFormat format, int dimension)
    {
      if (!SystemInfo.IsValidEnumValue((Enum) format))
        throw new ArgumentException("Failed SupportsVertexAttributeFormat; format is not a valid VertexAttributeFormat");
      return dimension >= 1 && dimension <= 4 ? SystemInfo.SupportsVertexAttributeFormatNative(format, dimension) : throw new ArgumentException("Failed SupportsVertexAttributeFormat; dimension must be in 1..4 range");
    }

    /// <summary>
    ///   <para>What NPOT (non-power of two size) texture support does the GPU provide? (Read Only)</para>
    /// </summary>
    public static NPOTSupport npotSupport => SystemInfo.GetNPOTSupport();

    /// <summary>
    ///   <para>Maximum texture size in pixels (Read Only).</para>
    /// </summary>
    public static int maxTextureSize => SystemInfo.GetMaxTextureSize();

    /// <summary>
    ///   <para>Maximum 3D texture size in pixels (Read Only).</para>
    /// </summary>
    public static int maxTexture3DSize => SystemInfo.GetMaxTexture3DSize();

    /// <summary>
    ///   <para>Maximum number of slices in a Texture array (Read Only).</para>
    /// </summary>
    public static int maxTextureArraySlices => SystemInfo.GetMaxTextureArraySlices();

    /// <summary>
    ///   <para>Maximum cubemap texture size in pixels (Read Only).</para>
    /// </summary>
    public static int maxCubemapSize => SystemInfo.GetMaxCubemapSize();

    /// <summary>
    ///   <para>Returns the maximum anisotropic level for anisotropic filtering that is supported on the device. </para>
    /// </summary>
    public static int maxAnisotropyLevel => SystemInfo.GetMaxAnisotropyLevel();

    internal static int maxRenderTextureSize => SystemInfo.GetMaxRenderTextureSize();

    /// <summary>
    ///   <para>Determines how many compute buffers Unity supports simultaneously in a vertex shader for reading. (Read Only)</para>
    /// </summary>
    public static int maxComputeBufferInputsVertex => SystemInfo.MaxComputeBufferInputsVertex();

    /// <summary>
    ///   <para>Determines how many compute buffers Unity supports simultaneously in a fragment shader for reading. (Read Only)</para>
    /// </summary>
    public static int maxComputeBufferInputsFragment => SystemInfo.MaxComputeBufferInputsFragment();

    /// <summary>
    ///   <para>Determines how many compute buffers Unity supports simultaneously in a geometry shader for reading. (Read Only)</para>
    /// </summary>
    public static int maxComputeBufferInputsGeometry => SystemInfo.MaxComputeBufferInputsGeometry();

    /// <summary>
    ///   <para>Determines how many compute buffers Unity supports simultaneously in a domain shader for reading. (Read Only)</para>
    /// </summary>
    public static int maxComputeBufferInputsDomain => SystemInfo.MaxComputeBufferInputsDomain();

    /// <summary>
    ///   <para>Determines how many compute buffers Unity supports simultaneously in a hull shader for reading. (Read Only)</para>
    /// </summary>
    public static int maxComputeBufferInputsHull => SystemInfo.MaxComputeBufferInputsHull();

    /// <summary>
    ///   <para>Determines how many compute buffers Unity supports simultaneously in a compute shader for reading. (Read Only)</para>
    /// </summary>
    public static int maxComputeBufferInputsCompute => SystemInfo.MaxComputeBufferInputsCompute();

    /// <summary>
    ///   <para>The largest total number of invocations in a single local work group that can be dispatched to a compute shader (Read Only).</para>
    /// </summary>
    public static int maxComputeWorkGroupSize => SystemInfo.GetMaxComputeWorkGroupSize();

    /// <summary>
    ///   <para>The maximum number of work groups that a compute shader can use in X dimension (Read Only).</para>
    /// </summary>
    public static int maxComputeWorkGroupSizeX => SystemInfo.GetMaxComputeWorkGroupSizeX();

    /// <summary>
    ///   <para>The maximum number of work groups that a compute shader can use in Y dimension (Read Only).</para>
    /// </summary>
    public static int maxComputeWorkGroupSizeY => SystemInfo.GetMaxComputeWorkGroupSizeY();

    /// <summary>
    ///   <para>The maximum number of work groups that a compute shader can use in Z dimension (Read Only).</para>
    /// </summary>
    public static int maxComputeWorkGroupSizeZ => SystemInfo.GetMaxComputeWorkGroupSizeZ();

    /// <summary>
    ///   <para>Size of the compute thread group that supports efficient memory sharing on the GPU (Read Only).</para>
    /// </summary>
    public static int computeSubGroupSize => SystemInfo.GetComputeSubGroupSize();

    /// <summary>
    ///   <para>Returns true when the platform supports asynchronous compute queues and false if otherwise.</para>
    /// </summary>
    public static bool supportsAsyncCompute => SystemInfo.SupportsAsyncCompute();

    /// <summary>
    ///   <para>Specifies whether the current platform supports the GPU Recorder or not. (Read Only).</para>
    /// </summary>
    public static bool supportsGpuRecorder => SystemInfo.SupportsGpuRecorder();

    /// <summary>
    ///   <para>true if the platform supports GraphicsFences, otherwise false.</para>
    /// </summary>
    public static bool supportsGraphicsFence => SystemInfo.SupportsGPUFence();

    /// <summary>
    ///   <para>Returns true if asynchronous readback of GPU data is available for this device and false otherwise.</para>
    /// </summary>
    public static bool supportsAsyncGPUReadback => SystemInfo.SupportsAsyncGPUReadback();

    /// <summary>
    ///   <para>Checks if ray tracing is supported by the current configuration.</para>
    /// </summary>
    public static bool supportsRayTracing => SystemInfo.SupportsRayTracing();

    /// <summary>
    ///   <para>Does the current renderer support binding constant buffers directly? (Read Only)</para>
    /// </summary>
    public static bool supportsSetConstantBuffer => SystemInfo.SupportsSetConstantBuffer();

    /// <summary>
    ///   <para>Minimum buffer offset (in bytes) when binding a constant buffer using Shader.SetConstantBuffer or Material.SetConstantBuffer.</para>
    /// </summary>
    public static int constantBufferOffsetAlignment
    {
      get => SystemInfo.MinConstantBufferOffsetAlignment();
    }

    /// <summary>
    ///   <para>The maximum size of a graphics buffer (GraphicsBuffer, ComputeBuffer, vertex/index buffer, etc.) in bytes (Read Only).</para>
    /// </summary>
    public static long maxGraphicsBufferSize => SystemInfo.MaxGraphicsBufferSize();

    /// <summary>
    ///   <para>Obsolete - use SystemInfo.constantBufferOffsetAlignment instead. Minimum buffer offset (in bytes) when binding a constant buffer using Shader.SetConstantBuffer or Material.SetConstantBuffer.</para>
    /// </summary>
    [Obsolete("Use SystemInfo.constantBufferOffsetAlignment instead.")]
    public static bool minConstantBufferOffsetAlignment => false;

    /// <summary>
    ///   <para>Returns true if the GPU supports partial mipmap chains (Read Only).</para>
    /// </summary>
    public static bool hasMipMaxLevel => SystemInfo.HasMipMaxLevel();

    /// <summary>
    ///   <para>Is streaming of texture mip maps supported? (Read Only)</para>
    /// </summary>
    public static bool supportsMipStreaming => SystemInfo.SupportsMipStreaming();

    [Obsolete("graphicsPixelFillrate is no longer supported in Unity 5.0+.")]
    public static int graphicsPixelFillrate => -1;

    /// <summary>
    ///   <para>True if the Graphics API takes RenderBufferLoadAction and RenderBufferStoreAction into account, false if otherwise.</para>
    /// </summary>
    public static bool usesLoadStoreActions => SystemInfo.UsesLoadStoreActions();

    /// <summary>
    ///   <para>Returns a bitwise combination of HDRDisplaySupportFlags describing the support for HDR displays on the system.</para>
    /// </summary>
    public static HDRDisplaySupportFlags hdrDisplaySupportFlags
    {
      get => SystemInfo.GetHDRDisplaySupportFlags();
    }

    /// <summary>
    ///   <para>Is conservative rasterization supported? (Read Only)</para>
    /// </summary>
    public static bool supportsConservativeRaster => SystemInfo.SupportsConservativeRaster();

    /// <summary>
    ///   <para>Boolean that indicates whether Multiview is supported (true if supported, false if not supported). (Read Only)</para>
    /// </summary>
    public static bool supportsMultiview => SystemInfo.SupportsMultiview();

    /// <summary>
    ///   <para>This property is true if the graphics API of the target build platform takes RenderBufferStoreAction.StoreAndResolve into account, false if otherwise.</para>
    /// </summary>
    public static bool supportsStoreAndResolveAction => SystemInfo.SupportsStoreAndResolveAction();

    /// <summary>
    ///   <para>Returns true if the platform supports multisample resolve of depth textures.</para>
    /// </summary>
    public static bool supportsMultisampleResolveDepth
    {
      get => SystemInfo.SupportsMultisampleResolveDepth();
    }

    [Obsolete("Vertex program support is required in Unity 5.0+")]
    public static bool supportsVertexPrograms => true;

    [FreeFunction("systeminfo::GetBatteryLevel")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern float GetBatteryLevel();

    [FreeFunction("systeminfo::GetBatteryStatus")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern BatteryStatus GetBatteryStatus();

    [FreeFunction("systeminfo::GetOperatingSystem")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern string GetOperatingSystem();

    [FreeFunction("systeminfo::GetOperatingSystemFamily")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern OperatingSystemFamily GetOperatingSystemFamily();

    [FreeFunction("systeminfo::GetProcessorType")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern string GetProcessorType();

    [FreeFunction("systeminfo::GetProcessorFrequencyMHz")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetProcessorFrequencyMHz();

    [FreeFunction("systeminfo::GetProcessorCount")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetProcessorCount();

    [FreeFunction("systeminfo::GetPhysicalMemoryMB")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetPhysicalMemoryMB();

    [FreeFunction("systeminfo::GetDeviceUniqueIdentifier")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern string GetDeviceUniqueIdentifier();

    [FreeFunction("systeminfo::GetDeviceName")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern string GetDeviceName();

    [FreeFunction("systeminfo::GetDeviceModel")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern string GetDeviceModel();

    [FreeFunction("systeminfo::SupportsAccelerometer")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsAccelerometer();

    [FreeFunction]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool IsGyroAvailable();

    [FreeFunction("systeminfo::SupportsLocationService")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsLocationService();

    [FreeFunction("systeminfo::SupportsVibration")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsVibration();

    [FreeFunction("systeminfo::SupportsAudio")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsAudio();

    [FreeFunction("systeminfo::GetDeviceType")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern DeviceType GetDeviceType();

    [FreeFunction("ScriptingGraphicsCaps::GetGraphicsMemorySize")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetGraphicsMemorySize();

    [FreeFunction("ScriptingGraphicsCaps::GetGraphicsDeviceName")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern string GetGraphicsDeviceName();

    [FreeFunction("ScriptingGraphicsCaps::GetGraphicsDeviceVendor")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern string GetGraphicsDeviceVendor();

    [FreeFunction("ScriptingGraphicsCaps::GetGraphicsDeviceID")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetGraphicsDeviceID();

    [FreeFunction("ScriptingGraphicsCaps::GetGraphicsDeviceVendorID")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetGraphicsDeviceVendorID();

    [FreeFunction("ScriptingGraphicsCaps::GetGraphicsDeviceType")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern GraphicsDeviceType GetGraphicsDeviceType();

    [FreeFunction("ScriptingGraphicsCaps::GetGraphicsUVStartsAtTop")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool GetGraphicsUVStartsAtTop();

    [FreeFunction("ScriptingGraphicsCaps::GetGraphicsDeviceVersion")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern string GetGraphicsDeviceVersion();

    [FreeFunction("ScriptingGraphicsCaps::GetGraphicsShaderLevel")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetGraphicsShaderLevel();

    [FreeFunction("ScriptingGraphicsCaps::GetGraphicsMultiThreaded")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool GetGraphicsMultiThreaded();

    [FreeFunction("ScriptingGraphicsCaps::GetRenderingThreadingMode")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern RenderingThreadingMode GetRenderingThreadingMode();

    [FreeFunction("ScriptingGraphicsCaps::HasHiddenSurfaceRemovalOnGPU")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool HasHiddenSurfaceRemovalOnGPU();

    [FreeFunction("ScriptingGraphicsCaps::HasDynamicUniformArrayIndexingInFragmentShaders")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool HasDynamicUniformArrayIndexingInFragmentShaders();

    [FreeFunction("ScriptingGraphicsCaps::SupportsShadows")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsShadows();

    [FreeFunction("ScriptingGraphicsCaps::SupportsRawShadowDepthSampling")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsRawShadowDepthSampling();

    [FreeFunction("SupportsMotionVectors")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsMotionVectors();

    [FreeFunction("ScriptingGraphicsCaps::Supports3DTextures")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool Supports3DTextures();

    [FreeFunction("ScriptingGraphicsCaps::SupportsCompressed3DTextures")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsCompressed3DTextures();

    [FreeFunction("ScriptingGraphicsCaps::Supports2DArrayTextures")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool Supports2DArrayTextures();

    [FreeFunction("ScriptingGraphicsCaps::Supports3DRenderTextures")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool Supports3DRenderTextures();

    [FreeFunction("ScriptingGraphicsCaps::SupportsCubemapArrayTextures")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsCubemapArrayTextures();

    [FreeFunction("ScriptingGraphicsCaps::SupportsAnisotropicFilter")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsAnisotropicFilter();

    [FreeFunction("ScriptingGraphicsCaps::GetCopyTextureSupport")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern CopyTextureSupport GetCopyTextureSupport();

    [FreeFunction("ScriptingGraphicsCaps::SupportsComputeShaders")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsComputeShaders();

    [FreeFunction("ScriptingGraphicsCaps::SupportsGeometryShaders")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsGeometryShaders();

    [FreeFunction("ScriptingGraphicsCaps::SupportsTessellationShaders")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsTessellationShaders();

    [FreeFunction("ScriptingGraphicsCaps::SupportsRenderTargetArrayIndexFromVertexShader")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsRenderTargetArrayIndexFromVertexShader();

    [FreeFunction("ScriptingGraphicsCaps::SupportsInstancing")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsInstancing();

    [FreeFunction("ScriptingGraphicsCaps::SupportsHardwareQuadTopology")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsHardwareQuadTopology();

    [FreeFunction("ScriptingGraphicsCaps::Supports32bitsIndexBuffer")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool Supports32bitsIndexBuffer();

    [FreeFunction("ScriptingGraphicsCaps::SupportsSparseTextures")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsSparseTextures();

    [FreeFunction("ScriptingGraphicsCaps::SupportedRenderTargetCount")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int SupportedRenderTargetCount();

    [FreeFunction("ScriptingGraphicsCaps::SupportsSeparatedRenderTargetsBlend")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsSeparatedRenderTargetsBlend();

    [FreeFunction("ScriptingGraphicsCaps::SupportedRandomWriteTargetCount")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int SupportedRandomWriteTargetCount();

    [FreeFunction("ScriptingGraphicsCaps::MaxComputeBufferInputsVertex")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int MaxComputeBufferInputsVertex();

    [FreeFunction("ScriptingGraphicsCaps::MaxComputeBufferInputsFragment")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int MaxComputeBufferInputsFragment();

    [FreeFunction("ScriptingGraphicsCaps::MaxComputeBufferInputsGeometry")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int MaxComputeBufferInputsGeometry();

    [FreeFunction("ScriptingGraphicsCaps::MaxComputeBufferInputsDomain")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int MaxComputeBufferInputsDomain();

    [FreeFunction("ScriptingGraphicsCaps::MaxComputeBufferInputsHull")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int MaxComputeBufferInputsHull();

    [FreeFunction("ScriptingGraphicsCaps::MaxComputeBufferInputsCompute")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int MaxComputeBufferInputsCompute();

    [FreeFunction("ScriptingGraphicsCaps::SupportsMultisampledTextures")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int SupportsMultisampledTextures();

    [FreeFunction("ScriptingGraphicsCaps::SupportsMultisampled2DArrayTextures")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsMultisampled2DArrayTextures();

    [FreeFunction("ScriptingGraphicsCaps::SupportsMultisampleAutoResolve")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsMultisampleAutoResolve();

    [FreeFunction("ScriptingGraphicsCaps::SupportsTextureWrapMirrorOnce")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int SupportsTextureWrapMirrorOnce();

    [FreeFunction("ScriptingGraphicsCaps::UsesReversedZBuffer")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool UsesReversedZBuffer();

    [FreeFunction("ScriptingGraphicsCaps::HasRenderTexture")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool HasRenderTextureNative(RenderTextureFormat format);

    [FreeFunction("ScriptingGraphicsCaps::SupportsBlendingOnRenderTextureFormat")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsBlendingOnRenderTextureFormatNative(
      RenderTextureFormat format);

    [FreeFunction("ScriptingGraphicsCaps::SupportsRandomWriteOnRenderTextureFormat")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsRandomWriteOnRenderTextureFormatNative(
      RenderTextureFormat format);

    [FreeFunction("ScriptingGraphicsCaps::SupportsTextureFormat")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsTextureFormatNative(TextureFormat format);

    [FreeFunction("ScriptingGraphicsCaps::SupportsVertexAttributeFormat")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsVertexAttributeFormatNative(
      VertexAttributeFormat format,
      int dimension);

    [FreeFunction("ScriptingGraphicsCaps::GetNPOTSupport")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern NPOTSupport GetNPOTSupport();

    [FreeFunction("ScriptingGraphicsCaps::GetMaxTextureSize")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetMaxTextureSize();

    [FreeFunction("ScriptingGraphicsCaps::GetMaxTexture3DSize")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetMaxTexture3DSize();

    [FreeFunction("ScriptingGraphicsCaps::GetMaxTextureArraySlices")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetMaxTextureArraySlices();

    [FreeFunction("ScriptingGraphicsCaps::GetMaxCubemapSize")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetMaxCubemapSize();

    [FreeFunction("ScriptingGraphicsCaps::GetMaxAnisotropyLevel")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetMaxAnisotropyLevel();

    [FreeFunction("ScriptingGraphicsCaps::GetMaxRenderTextureSize")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetMaxRenderTextureSize();

    [FreeFunction("ScriptingGraphicsCaps::GetMaxComputeWorkGroupSize")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetMaxComputeWorkGroupSize();

    [FreeFunction("ScriptingGraphicsCaps::GetMaxComputeWorkGroupSizeX")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetMaxComputeWorkGroupSizeX();

    [FreeFunction("ScriptingGraphicsCaps::GetMaxComputeWorkGroupSizeY")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetMaxComputeWorkGroupSizeY();

    [FreeFunction("ScriptingGraphicsCaps::GetMaxComputeWorkGroupSizeZ")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetMaxComputeWorkGroupSizeZ();

    [FreeFunction("ScriptingGraphicsCaps::GetComputeSubGroupSize")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetComputeSubGroupSize();

    [FreeFunction("ScriptingGraphicsCaps::SupportsAsyncCompute")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsAsyncCompute();

    [FreeFunction("ScriptingGraphicsCaps::SupportsGpuRecorder")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsGpuRecorder();

    [FreeFunction("ScriptingGraphicsCaps::SupportsGPUFence")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsGPUFence();

    [FreeFunction("ScriptingGraphicsCaps::SupportsAsyncGPUReadback")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsAsyncGPUReadback();

    [FreeFunction("ScriptingGraphicsCaps::SupportsRayTracing")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsRayTracing();

    [FreeFunction("ScriptingGraphicsCaps::SupportsSetConstantBuffer")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsSetConstantBuffer();

    [FreeFunction("ScriptingGraphicsCaps::MinConstantBufferOffsetAlignment")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int MinConstantBufferOffsetAlignment();

    [FreeFunction("ScriptingGraphicsCaps::MaxGraphicsBufferSize")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern long MaxGraphicsBufferSize();

    [FreeFunction("ScriptingGraphicsCaps::HasMipMaxLevel")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool HasMipMaxLevel();

    [FreeFunction("ScriptingGraphicsCaps::SupportsMipStreaming")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsMipStreaming();

    [FreeFunction("ScriptingGraphicsCaps::IsFormatSupported")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    public static extern bool IsFormatSupported(GraphicsFormat format, FormatUsage usage);

    [FreeFunction("ScriptingGraphicsCaps::GetCompatibleFormat")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    public static extern GraphicsFormat GetCompatibleFormat(
      GraphicsFormat format,
      FormatUsage usage);

    /// <summary>
    ///   <para>Returns the platform-specific GraphicsFormat that is associated with the DefaultFormat.</para>
    /// </summary>
    /// <param name="format">The DefaultFormat format to look up.</param>
    [FreeFunction("ScriptingGraphicsCaps::GetGraphicsFormat")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    public static extern GraphicsFormat GetGraphicsFormat(DefaultFormat format);

    /// <summary>
    ///   <para>Checks if the target platform supports the MSAA samples count in the RenderTextureDescriptor argument.</para>
    /// </summary>
    /// <param name="desc">The RenderTextureDescriptor to check.</param>
    /// <returns>
    ///   <para>If the target platform supports the given MSAA samples count of RenderTextureDescriptor, returns the given MSAA samples count. Otherwise returns a lower fallback MSAA samples count value that the target platform supports.</para>
    /// </returns>
    [FreeFunction("ScriptingGraphicsCaps::GetRenderTextureSupportedMSAASampleCount")]
    public static int GetRenderTextureSupportedMSAASampleCount(RenderTextureDescriptor desc)
    {
      return SystemInfo.GetRenderTextureSupportedMSAASampleCount_Injected(ref desc);
    }

    [FreeFunction("ScriptingGraphicsCaps::UsesLoadStoreActions")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool UsesLoadStoreActions();

    [FreeFunction("ScriptingGraphicsCaps::GetHDRDisplaySupportFlags")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern HDRDisplaySupportFlags GetHDRDisplaySupportFlags();

    [FreeFunction("ScriptingGraphicsCaps::SupportsConservativeRaster")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsConservativeRaster();

    [FreeFunction("ScriptingGraphicsCaps::SupportsMultiview")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsMultiview();

    [FreeFunction("ScriptingGraphicsCaps::SupportsStoreAndResolveAction")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsStoreAndResolveAction();

    [FreeFunction("ScriptingGraphicsCaps::SupportsMultisampleResolveDepth")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern bool SupportsMultisampleResolveDepth();

    /// <summary>
    ///   <para>This functionality is deprecated, and should no longer be used. Please use SystemInfo.supportsGraphicsFence.</para>
    /// </summary>
    [Obsolete("SystemInfo.supportsGPUFence has been deprecated, use SystemInfo.supportsGraphicsFence instead (UnityUpgradable) ->  supportsGraphicsFence", true)]
    public static bool supportsGPUFence => false;

    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern int GetRenderTextureSupportedMSAASampleCount_Injected(
      ref RenderTextureDescriptor desc);
  }
}
